package com.wicket.okrapp.biz.service.impl;

import com.wicket.okrapp.base.service.*;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleDetailReq;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.biz.service.nb.NbRefreshTree;
import com.wicket.okrapp.biz.service.dto.common.EvaObjTargetCycleDto;
import com.wicket.okrapp.base.service.dto.common.VirtualOrgMemberDeptDto;
import com.wicket.okrapp.base.service.dto.common.VirtualOrgMemberDto;
import com.wicket.okrapp.biz.service.VirtualOrgService;
import com.wicket.okrapp.biz.service.TargetCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetObjective;
import com.wicket.okrapp.base.service.dto.req.QueryTargetObjDetailReq;
import com.wicket.okrapp.biz.service.TimingTaskService;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleListReq;
import java.util.ArrayList;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.biz.service.IndexSystemService;
import com.wicket.okrapp.dal.po.mbg.OmsVirtualOrgMember;
import com.wicket.okrapp.base.service.dto.req.QueryVirtualOrgMemberDetailReq;
import com.wicket.okrapp.dal.po.mbg.OmsVirtualOrgMemberDept;
import com.wicket.okrapp.base.service.dto.req.ImplementUnrestraintQueryLeadDeptReq;
import com.wicket.okrcomponent.integration.dto.ImplementTwoValuesIsEqualityComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementTwoValuesIsEqualityComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryClassMatchResultToAnswerDetailComRespDto;
import com.wicket.okrcomponent.integration.dto.QueryClassMatchResultToAnswerDetailComReqDto;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrapp.biz.service.WeightTargetService;
import com.wicket.okrapp.biz.service.OffStateService;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class RefreshTreeServiceImpl
  implements com.wicket.okrapp.biz.service.RefreshTreeService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private NbRefreshTree nbRefreshTree;
//@Resource
 //private undefinedService undefinedService;
@Resource
  private MOmsVirtualOrgMemberDeptService mOmsVirtualOrgMemberDeptService;
@Resource
  private MOmsVirtualOrgMemberService mOmsVirtualOrgMemberService;
@Resource
  private VirtualOrgService virtualOrgService;
@Resource
  private TargetCycleService targetCycleService;
@Resource
  private MOmsTargetObjectiveService mOmsTargetObjectiveService;
@Resource
  private TimingTaskService timingTaskService;
@Resource
  private IndexSystemService indexSystemService;
@Resource
  private MOmsExecuteProgressService mOmsExecuteProgressService;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private WeightTargetService weightTargetService;
@Resource
  private OffStateService offStateService;
@Resource
  private MOmsTaskService mOmsTaskService;
//@Resource
 //private MCustomFields3Service mCustomFields3Service;
/**
   * D3-分析生命周期新增/撤销存档操作类型(公共)[6593]
   * gen by moon at 5/29/2023, 4:49:50 AM
   */
  @Trace(operationName = "D3-分析生命周期新增/撤销存档操作类型(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyseLifeCycleAddOpeTypeComRespDto implementAnalyseLifeCycleAddOpeTypeCom(ImplementAnalyseLifeCycleAddOpeTypeComReqDto reqDto){
    
      
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 =null;
CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 =null;
//virtualUsage 3-3-09查被评对象目标周期详情  41138
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:925760_1_41138
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:925762_1_41138
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:925757_1_41138
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925758_1_41138
queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925759_1_41138
queryEvaObjTargetCycleDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925761_1_41138
    }
  
    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetId(),"D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-冗余目标ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-分析生命周期新增/撤销存档操作类型(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
if((omsEvaluationObjectTargetCycle == null )) {
        //if(3-3-09查被评对象目标周期详情.出参 值等于空 )  41141
        
ImplementAnalyseEvaObjTableTypeCodeComRespDto implementAnalyseEvaObjTableTypeCodeComRespDto = null;
    ImplementAnalyseEvaObjTableTypeCodeComReqDto implementAnalyseEvaObjTableTypeCodeComReqDto=new ImplementAnalyseEvaObjTableTypeCodeComReqDto();
  if(reqDto!=null){
      implementAnalyseEvaObjTableTypeCodeComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:989260_1_43356
    }

    /*D3分析被评对象内容表类型编码(公共)[6991]   */
    Assert.isNull(implementAnalyseEvaObjTableTypeCodeComReqDto.getEvaObjTypeCode(),"D3-分析生命周期新增/撤销存档操作类型(公共)-D3分析被评对象内容表类型编码(公共)-被评对象类型编码不能为空",false);
      implementAnalyseEvaObjTableTypeCodeComRespDto = implementAnalyseEvaObjTableTypeCodeCom(implementAnalyseEvaObjTableTypeCodeComReqDto)/*vcase invoke 同服务,同domain*/;



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setSubjectLifeCycleOpt("CREATE");//sourceId:925748_1_41142
  
    /*生命周期操作：新增[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getSubjectLifeCycleOpt(),"D3-分析生命周期新增/撤销存档操作类型(公共)-生命周期操作：新增-生命周期操作不能为空",false);
      receptionServiceRes = nbRefreshTree.calculateAcceptAboveFields(receptionServiceReq);
      
      
      
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    if(implementAnalyseEvaObjTableTypeCodeComRespDto !=null){
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setSubjectLifeCycleOpt(receptionServiceRes.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925731_1_41143
    }
if(implementAnalyseEvaObjTableTypeCodeComRespDto!=null){
      receptionServiceReq_1.setEvaObjTableTypeCode(implementAnalyseEvaObjTableTypeCodeComRespDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989263_1_41143
    }

    /*约定出参：生命周期操作[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getSubjectLifeCycleOpt(),"D3-分析生命周期新增/撤销存档操作类型(公共)-约定出参：生命周期操作-生命周期操作不能为空",false);
      receptionServiceRes_2 = nbRefreshTree.calculateAcceptAboveFields(receptionServiceReq_1);
      
      
      receptionServiceRes_3 = receptionServiceRes_2;
      }
      }
else if((omsEvaluationObjectTargetCycle != null &&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsArchive() !=null && omsEvaluationObjectTargetCycle.getIsArchive().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getArchivngType() !=null && omsEvaluationObjectTargetCycle.getArchivngType().equals("ARCHIVED")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getSubjectLifeCycle() !=null && omsEvaluationObjectTargetCycle.getSubjectLifeCycle().equals("ARCHIVING"))){
       //elseif((3-3-09查目标父周期是否存在.出参 值不等于空  and 3-3-09查目标父周期是否存在.是否存档 等于 是 and 3-3-09查目标父周期是否存在.存档类型 等于 已归档 and 3-3-09查目标父周期是否存在.主体生命周期 等于 历史存档))  41145
      
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_2.setSubjectLifeCycleOpt("UNDO_ARCHIVE");//sourceId:925754_1_41146
  
    /*生命周期操作：撤销存档[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getSubjectLifeCycleOpt(),"D3-分析生命周期新增/撤销存档操作类型(公共)-生命周期操作：撤销存档-生命周期操作不能为空",false);
      receptionServiceRes_4 = nbRefreshTree.calculateAcceptAboveFields(receptionServiceReq_2);
      
      
      
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    if(omsEvaluationObjectTargetCycle !=null){
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setSubjectLifeCycleOpt(receptionServiceRes_4.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925731_1_41147
    }
if(omsEvaluationObjectTargetCycle!=null){
      receptionServiceReq_3.setEvaObjTableTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989263_1_41147
    }

    /*约定出参：生命周期操作[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getSubjectLifeCycleOpt(),"D3-分析生命周期新增/撤销存档操作类型(公共)-约定出参：生命周期操作-生命周期操作不能为空",false);
      receptionServiceRes_6 = nbRefreshTree.calculateAcceptAboveFields(receptionServiceReq_3);
      
      
      receptionServiceRes_3 = receptionServiceRes_6;
    }
    }
ImplementAnalyseLifeCycleAddOpeTypeComRespDto retData = new ImplementAnalyseLifeCycleAddOpeTypeComRespDto();
  if(omsEvaluationObjectTargetCycle_1!=null){
      retData.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:925786_1
retData.setEvaObjEntityId(omsEvaluationObjectTargetCycle_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:925926_1
retData.setEvaObjTypeCode(omsEvaluationObjectTargetCycle_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925928_1
retData.setTargetCycleContentId(omsEvaluationObjectTargetCycle_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925929_1
retData.setTargetCycleContentTypeCode(omsEvaluationObjectTargetCycle_1.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925930_1
    }
if(receptionServiceRes_3!=null){
      retData.setEvaObjTableTypeCode(receptionServiceRes_3.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989265_1
      retData.setSubjectLifeCycleOpt(receptionServiceRes_3.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925782_1
    }
  

  
  
return retData;
  }
/**
   * D3-执行构建部门目标任务书树(公共)[6595]
   * gen by moon at 5/11/2023, 8:48:00 PM
   */
  @Trace(operationName = "D3-执行构建部门目标任务书树(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCreateFlevelObjTaskDutyDeptComRespDto implementCreateFlevelObjTaskDutyDeptCom(ImplementCreateFlevelObjTaskDutyDeptComReqDto reqDto){
    
      
      ImplementCreateFlevelObjTaskDutyDeptComRespDto retData = new ImplementCreateFlevelObjTaskDutyDeptComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3执行新增或删除三棵树叶子节点(公共)[6572]
   * gen by moon at 3/19/2024, 11:57:51 AM
   */
  @Trace(operationName = "D3执行新增或删除三棵树叶子节点(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAddOrDelThreeTreeLeafComRespDto implementAddOrDelThreeTreeLeafCom(ImplementAddOrDelThreeTreeLeafComReqDto reqDto){
    
      
      if((reqDto!= null&&  reqDto.getEvaObjTargetCycleList() !=null && reqDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3-执行更新三棵树叶子节点(公共).被评对象目标周期列表数据集条数 大于 0)  40975
        
//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: reqDto.getEvaObjTargetCycleList()){ 
      
ImplementAnalyseLifeCycleOpeTypeComRespDto implementAnalyseLifeCycleOpeTypeComRespDto = null;
    ImplementAnalyseLifeCycleOpeTypeComReqDto implementAnalyseLifeCycleOpeTypeComReqDto=new ImplementAnalyseLifeCycleOpeTypeComReqDto();
  if(circulationCollectionsRes!=null){
      implementAnalyseLifeCycleOpeTypeComReqDto.setSubjectLifeCycle(circulationCollectionsRes.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:925382_1_41133
    }
  
    /*D3分析生命周期操作类型(公共)[6592]   */
    Assert.isNull(implementAnalyseLifeCycleOpeTypeComReqDto.getSubjectLifeCycle(),"D3执行新增或删除三棵树叶子节点(公共)-D3分析生命周期操作类型(公共)-主体生命周期不能为空",false);
      implementAnalyseLifeCycleOpeTypeComRespDto = implementAnalyseLifeCycleOpeTypeCom(implementAnalyseLifeCycleOpeTypeComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
ImplementVirtualOrgOrVirtualOrgMemberComRespDto implementVirtualOrgOrVirtualOrgMemberComRespDto = null;
    ImplementVirtualOrgOrVirtualOrgMemberComReqDto implementVirtualOrgOrVirtualOrgMemberComReqDto=new ImplementVirtualOrgOrVirtualOrgMemberComReqDto();
  if(circulationCollectionsRes!=null){
      implementVirtualOrgOrVirtualOrgMemberComReqDto.setEvaObjEntityId(circulationCollectionsRes.getEvaObjEntityId());//SimpleFieldAssign//sourceId:923611_1_41012
implementVirtualOrgOrVirtualOrgMemberComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:921533_1_41012
    }
if(reqDto!=null){
      implementVirtualOrgOrVirtualOrgMemberComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:921530_1_41012
    }
  
    /*D3-执行虚拟组织或成员存在判断(公共)[6575]   */
    Assert.isNull(implementVirtualOrgOrVirtualOrgMemberComReqDto.getEvaObjEntityId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-执行虚拟组织或成员存在判断(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementVirtualOrgOrVirtualOrgMemberComReqDto.getEvaObjTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3-执行虚拟组织或成员存在判断(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementVirtualOrgOrVirtualOrgMemberComReqDto.getTargetCycleContentId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-执行虚拟组织或成员存在判断(公共)-关联目标内容ID不能为空",false);
      implementVirtualOrgOrVirtualOrgMemberComRespDto = virtualOrgService.implementVirtualOrgOrVirtualOrgMemberCom(implementVirtualOrgOrVirtualOrgMemberComReqDto)/*vcase invoke isSameApp*/;
      
      
      
if((implementVirtualOrgOrVirtualOrgMemberComRespDto!= null&&  implementVirtualOrgOrVirtualOrgMemberComRespDto.getTureOrFalse() !=null && implementVirtualOrgOrVirtualOrgMemberComRespDto.getTureOrFalse().equals("FALSE"))&&(reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT")||reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL")||reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))) {
        //if(D3-执行虚拟组织或成员存在判断(公共).是否 等于 否 and (D3执行新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 OKR责任主体部门 or D3执行新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 OKR责任主体个人 or D3执行新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 一级部门目标任务责任部门))  41013
        
ImplementAnalyseThreeTreeLeafLifeOpeComRespDto implementAnalyseThreeTreeLeafLifeOpeComRespDto = null;
    if(implementAnalyseLifeCycleOpeTypeComRespDto !=null){
          ImplementAnalyseThreeTreeLeafLifeOpeComReqDto implementAnalyseThreeTreeLeafLifeOpeComReqDto=new ImplementAnalyseThreeTreeLeafLifeOpeComReqDto();
  if(implementAnalyseLifeCycleOpeTypeComRespDto!=null){
      implementAnalyseThreeTreeLeafLifeOpeComReqDto.setSubjectLifeCycleOpt(implementAnalyseLifeCycleOpeTypeComRespDto.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:926044_1_41165
    }
if(circulationCollectionsRes!=null){
      implementAnalyseThreeTreeLeafLifeOpeComReqDto.setEvaObjEntityId(circulationCollectionsRes.getEvaObjEntityId());//SimpleFieldAssign//sourceId:926040_1_41165
implementAnalyseThreeTreeLeafLifeOpeComReqDto.setEvaObjTableTypeCode(circulationCollectionsRes.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:926045_1_41165
implementAnalyseThreeTreeLeafLifeOpeComReqDto.setTargetCycleContentTypeCode("OBJECTIVE");//sourceId:926046_1_41165
implementAnalyseThreeTreeLeafLifeOpeComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:926042_1_41165
    }
if(reqDto!=null){
      implementAnalyseThreeTreeLeafLifeOpeComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:926041_1_41165
implementAnalyseThreeTreeLeafLifeOpeComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:926043_1_41165
    }
  
    /*D3执行分析三棵树叶子生命周期操作(公共)[6591]   */
    Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getSubjectLifeCycleOpt(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-生命周期操作不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getEvaObjEntityId(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getEvaObjTableTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表类型编码不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getEvaObjTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getTargetCycleContentTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getTargetCycleContentId(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto.getTargetId(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-冗余目标ID不能为空",false);
      implementAnalyseThreeTreeLeafLifeOpeComRespDto = implementAnalyseThreeTreeLeafLifeOpeCom(implementAnalyseThreeTreeLeafLifeOpeComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
      }
//ModelCode: circulationEnd
        }
      
      }
if((reqDto!= null&&  reqDto.getVirtualOrgMemberDeptList() !=null && reqDto.getVirtualOrgMemberDeptList().size()>0||reqDto!= null&&  reqDto.getVirtualOrgMemberList() !=null && reqDto.getVirtualOrgMemberList().size()>0)) {
        //if((D3-新增或删除三棵树叶子节点(公共).虚拟成员部门列表数据集条数 大于 0 or D3-新增或删除三棵树叶子节点(公共).虚拟组织成员列表数据集条数 大于 0))  40977
        
if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT")||reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))) {
        //if((D3-新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 OKR责任主体部门 or D3-新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 一级部门目标任务责任部门))  41102
        
//ModelCode: circulationCollections
        for (VirtualOrgMemberDeptDto circulationCollectionsRes_2: reqDto.getVirtualOrgMemberDeptList()){ 
      
ImplementAnalyseLifeCycleAddOpeTypeComRespDto implementAnalyseLifeCycleAddOpeTypeComRespDto = null;
    ImplementAnalyseLifeCycleAddOpeTypeComReqDto implementAnalyseLifeCycleAddOpeTypeComReqDto=new ImplementAnalyseLifeCycleAddOpeTypeComReqDto();
  if(circulationCollectionsRes_2!=null){
      implementAnalyseLifeCycleAddOpeTypeComReqDto.setEvaObjEntityId(circulationCollectionsRes_2.getEntityId());//SimpleFieldAssign//sourceId:925804_1_41148
implementAnalyseLifeCycleAddOpeTypeComReqDto.setTargetCycleContentId(circulationCollectionsRes_2.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:925806_1_41148
    }
if(reqDto!=null){
      implementAnalyseLifeCycleAddOpeTypeComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925805_1_41148
implementAnalyseLifeCycleAddOpeTypeComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925807_1_41148
    }
  
    /*D3-分析生命周期新增/撤销存档操作类型(公共)[6593]   */
    Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto.getEvaObjEntityId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto.getEvaObjTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto.getTargetCycleContentId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto.getTargetId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-冗余目标ID不能为空",false);
      implementAnalyseLifeCycleAddOpeTypeComRespDto = implementAnalyseLifeCycleAddOpeTypeCom(implementAnalyseLifeCycleAddOpeTypeComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
if((implementAnalyseLifeCycleAddOpeTypeComRespDto!= null&&  implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt() !=null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt().equals("CREATE")&&reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT")&&!(implementAnalyseLifeCycleAddOpeTypeComRespDto!= null&&  implementAnalyseLifeCycleAddOpeTypeComRespDto.getTargetCycleContentTypeCode() !=null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")))) {
        //if((D3-分析生命周期操作类型（新增或撤销存档）.生命周期操作 等于 新增 and D3执行新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 OKR责任主体部门 and D3-分析生命周期操作类型（新增或撤销存档）.关联目标内容类型编码 不等于 目标分类))  41114
        
StructureOkrDeptCurrentSuperiorComRespDto structureOkrDeptCurrentSuperiorComRespDto = null;
    if(implementAnalyseLifeCycleAddOpeTypeComRespDto !=null){
          StructureOkrDeptCurrentSuperiorComReqDto structureOkrDeptCurrentSuperiorComReqDto=new StructureOkrDeptCurrentSuperiorComReqDto();
  if(circulationCollectionsRes_2!=null){
      structureOkrDeptCurrentSuperiorComReqDto.setEvaObjEntityId(circulationCollectionsRes_2.getDeptId());//SimpleFieldAssign//sourceId:921584_1_41115
structureOkrDeptCurrentSuperiorComReqDto.setObjectiveId(circulationCollectionsRes_2.getEntityId());//SimpleFieldAssign//sourceId:921581_1_41115
structureOkrDeptCurrentSuperiorComReqDto.setBatchCode(circulationCollectionsRes_2.getBatchCode());//SimpleFieldAssign//sourceId:921583_1_41115
    }
if(implementAnalyseLifeCycleAddOpeTypeComRespDto!=null){
      structureOkrDeptCurrentSuperiorComReqDto.setEvaObjTableTypeCode(implementAnalyseLifeCycleAddOpeTypeComRespDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:921585_1_41115
    }
if(reqDto!=null){
      structureOkrDeptCurrentSuperiorComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:921586_1_41115
structureOkrDeptCurrentSuperiorComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:921582_1_41115
    }
  
    /*D3-3构建OKR部门当前与上级目标(公共)[3332]   */
    Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getEvaObjEntityId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getEvaObjTableTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象内容表类型编码不能为空",false);
Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getEvaObjTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象类型编码不能为空",false);
Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getObjectiveId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-指标ID不能为空",false);
Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getTargetId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-冗余目标ID不能为空",false);
Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto.getBatchCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-批次标识不能为空",false);
      structureOkrDeptCurrentSuperiorComRespDto = targetCycleService.structureOkrDeptCurrentSuperiorCom(structureOkrDeptCurrentSuperiorComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
      }
else if((implementAnalyseLifeCycleAddOpeTypeComRespDto!= null&&  implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt() !=null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt().equals("CREATE")&&reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getTableTypeCode() !=null && circulationCollectionsRes_2.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))){
       //elseif((D3-分析生命周期操作类型（新增或撤销存档）.生命周期操作 等于 新增 and D3执行新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 一级部门目标任务责任部门 and M3执行虚拟成员部门【循环开始】.冗余内容表类型编码 等于 指标表))  41120
      
ImplementCreateFlevelObjTaskTreeDeptComRespDto implementCreateFlevelObjTaskTreeDeptComRespDto = null;
    ImplementCreateFlevelObjTaskTreeDeptComReqDto implementCreateFlevelObjTaskTreeDeptComReqDto=new ImplementCreateFlevelObjTaskTreeDeptComReqDto();
  if(circulationCollectionsRes_2!=null){
      implementCreateFlevelObjTaskTreeDeptComReqDto.setEvaObjEntityId(circulationCollectionsRes_2.getDeptId());//SimpleFieldAssign//sourceId:926382_1_43581
implementCreateFlevelObjTaskTreeDeptComReqDto.setObjectiveId(circulationCollectionsRes_2.getEntityId());//SimpleFieldAssign//sourceId:926380_1_43581
implementCreateFlevelObjTaskTreeDeptComReqDto.setEvaluationTemplateId(circulationCollectionsRes_2.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:926381_1_43581
    }
  
    /*D3构建部门目标任务书树(公共)[6595]   */
    Assert.isNull(implementCreateFlevelObjTaskTreeDeptComReqDto.getEvaObjEntityId(),"D3执行新增或删除三棵树叶子节点(公共)-D3构建部门目标任务书树(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementCreateFlevelObjTaskTreeDeptComReqDto.getObjectiveId(),"D3执行新增或删除三棵树叶子节点(公共)-D3构建部门目标任务书树(公共)-指标ID不能为空",false);
Assert.isNull(implementCreateFlevelObjTaskTreeDeptComReqDto.getEvaluationTemplateId(),"D3执行新增或删除三棵树叶子节点(公共)-D3构建部门目标任务书树(公共)-冗余评价模板ID不能为空",false);
      implementCreateFlevelObjTaskTreeDeptComRespDto = implementCreateFlevelObjTaskTreeDeptCom(implementCreateFlevelObjTaskTreeDeptComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
    }
else if((implementAnalyseLifeCycleAddOpeTypeComRespDto!= null&&  implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt() !=null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt().equals("UNDO_ARCHIVE")&&!(implementAnalyseLifeCycleAddOpeTypeComRespDto!= null&&  implementAnalyseLifeCycleAddOpeTypeComRespDto.getTargetCycleContentTypeCode() !=null && implementAnalyseLifeCycleAddOpeTypeComRespDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")))){
       //elseif((D3-分析生命周期操作类型（新增或撤销存档）.生命周期操作 等于 撤销存档 and D3-分析生命周期操作类型（新增或撤销存档）.关联目标内容类型编码 不等于 目标分类))  41151
      
ImplementAnalyseThreeTreeLeafLifeOpeComRespDto implementAnalyseThreeTreeLeafLifeOpeComRespDto_1 = null;
    if(implementAnalyseLifeCycleAddOpeTypeComRespDto !=null){
          ImplementAnalyseThreeTreeLeafLifeOpeComReqDto implementAnalyseThreeTreeLeafLifeOpeComReqDto_1=new ImplementAnalyseThreeTreeLeafLifeOpeComReqDto();
  implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setTargetCycleContentTypeCode("OBJECTIVE");//sourceId:926046_1_41176
if(implementAnalyseLifeCycleAddOpeTypeComRespDto!=null){
      implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setSubjectLifeCycleOpt(implementAnalyseLifeCycleAddOpeTypeComRespDto.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:926044_1_41176
implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setEvaObjTableTypeCode(implementAnalyseLifeCycleAddOpeTypeComRespDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:926045_1_41176
    }
if(circulationCollectionsRes_2!=null){
      implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setEvaObjEntityId(circulationCollectionsRes_2.getDeptId());//SimpleFieldAssign//sourceId:926040_1_41176
implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setTargetCycleContentId(circulationCollectionsRes_2.getEntityId());//SimpleFieldAssign//sourceId:926042_1_41176
    }
if(reqDto!=null){
      implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:926041_1_41176
implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:926043_1_41176
    }
  
    /*D3执行分析三棵树叶子生命周期操作(公共)[6591]   */
    Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getSubjectLifeCycleOpt(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-生命周期操作不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getEvaObjEntityId(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getEvaObjTableTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表类型编码不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getEvaObjTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getTargetCycleContentTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getTargetCycleContentId(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1.getTargetId(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-冗余目标ID不能为空",false);
      implementAnalyseThreeTreeLeafLifeOpeComRespDto_1 = implementAnalyseThreeTreeLeafLifeOpeCom(implementAnalyseThreeTreeLeafLifeOpeComReqDto_1)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
    }
//ModelCode: circulationEnd
        }
      
      }
else if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))){
       //elseif(D3-新增或删除三棵树叶子节点(公共).被评对象类型编码 等于 OKR责任主体个人)  41103
      
//ModelCode: circulationCollections
        for (VirtualOrgMemberDto circulationCollectionsRes_4: reqDto.getVirtualOrgMemberList()){ 
      
ImplementAnalyseLifeCycleAddOpeTypeComRespDto implementAnalyseLifeCycleAddOpeTypeComRespDto_2 = null;
    ImplementAnalyseLifeCycleAddOpeTypeComReqDto implementAnalyseLifeCycleAddOpeTypeComReqDto_1=new ImplementAnalyseLifeCycleAddOpeTypeComReqDto();
  if(circulationCollectionsRes_4!=null){
      implementAnalyseLifeCycleAddOpeTypeComReqDto_1.setEvaObjEntityId(circulationCollectionsRes_4.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:925804_1_41177
implementAnalyseLifeCycleAddOpeTypeComReqDto_1.setTargetCycleContentId(circulationCollectionsRes_4.getEntityId());//SimpleFieldAssign//sourceId:925806_1_41177
    }
if(reqDto!=null){
      implementAnalyseLifeCycleAddOpeTypeComReqDto_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925805_1_41177
implementAnalyseLifeCycleAddOpeTypeComReqDto_1.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925807_1_41177
    }
  
    /*D3-分析生命周期新增/撤销存档操作类型(公共)[6593]   */
    Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto_1.getEvaObjEntityId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto_1.getEvaObjTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto_1.getTargetCycleContentId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAnalyseLifeCycleAddOpeTypeComReqDto_1.getTargetId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-分析生命周期新增/撤销存档操作类型(公共)-冗余目标ID不能为空",false);
      implementAnalyseLifeCycleAddOpeTypeComRespDto_2 = implementAnalyseLifeCycleAddOpeTypeCom(implementAnalyseLifeCycleAddOpeTypeComReqDto_1)/*vcase invoke 同服务,同domain*/;
      
      
      
if((implementAnalyseLifeCycleAddOpeTypeComRespDto_2!= null&& implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getEvaObjTargetCycleId() == null &&circulationCollectionsRes_4!= null&&  circulationCollectionsRes_4.getTableTypeCode() !=null && circulationCollectionsRes_4.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
        //if((D3-分析生命周期操作类型（新增/撤销存档）.被评对象目标周期ID 值等于空  and M3执行虚拟组织成员【循环开始】.冗余内容表类型编码 等于 指标表))  41117
        
StructureOkrDeptCurrentSuperiorComRespDto structureOkrDeptCurrentSuperiorComRespDto_1 = null;
    if(implementAnalyseLifeCycleAddOpeTypeComRespDto_2 !=null){
          StructureOkrDeptCurrentSuperiorComReqDto structureOkrDeptCurrentSuperiorComReqDto_1=new StructureOkrDeptCurrentSuperiorComReqDto();
  if(circulationCollectionsRes_4!=null){
      structureOkrDeptCurrentSuperiorComReqDto_1.setEvaObjEntityId(circulationCollectionsRes_4.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:921584_1_41191
structureOkrDeptCurrentSuperiorComReqDto_1.setObjectiveId(circulationCollectionsRes_4.getEntityId());//SimpleFieldAssign//sourceId:921581_1_41191
structureOkrDeptCurrentSuperiorComReqDto_1.setBatchCode(circulationCollectionsRes_4.getBatchCode());//SimpleFieldAssign//sourceId:921583_1_41191
    }
if(implementAnalyseLifeCycleAddOpeTypeComRespDto_2!=null){
      structureOkrDeptCurrentSuperiorComReqDto_1.setEvaObjTableTypeCode(implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:921585_1_41191
    }
if(reqDto!=null){
      structureOkrDeptCurrentSuperiorComReqDto_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:921586_1_41191
structureOkrDeptCurrentSuperiorComReqDto_1.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:921582_1_41191
    }
  
    /*D3-3构建OKR部门当前与上级目标(公共)[3332]   */
    Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getEvaObjEntityId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getEvaObjTableTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象内容表类型编码不能为空",false);
Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getEvaObjTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-被评对象类型编码不能为空",false);
Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getObjectiveId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-指标ID不能为空",false);
Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getTargetId(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-冗余目标ID不能为空",false);
Assert.isNull(structureOkrDeptCurrentSuperiorComReqDto_1.getBatchCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3-3构建OKR部门当前与上级目标(公共)-批次标识不能为空",false);
      structureOkrDeptCurrentSuperiorComRespDto_1 = targetCycleService.structureOkrDeptCurrentSuperiorCom(structureOkrDeptCurrentSuperiorComReqDto_1)/*vcase invoke isSameApp*/;
      
      
      
           }
      }
else if((implementAnalyseLifeCycleAddOpeTypeComRespDto_2!= null&& implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getEvaObjTargetCycleId() != null &&implementAnalyseLifeCycleAddOpeTypeComRespDto_2!= null&&  implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getSubjectLifeCycleOpt() !=null && implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getSubjectLifeCycleOpt().equals("UNDO_ARCHIVE")&&!(implementAnalyseLifeCycleAddOpeTypeComRespDto_2!= null&&  implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getTargetCycleContentTypeCode() !=null && implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")))){
       //elseif((D3-分析生命周期操作类型（新增/撤销存档）.被评对象目标周期ID 值不等于空  and D3-分析生命周期操作类型（新增/撤销存档）.生命周期操作 等于 撤销存档 and D3-分析生命周期操作类型（新增/撤销存档）.关联目标内容类型编码 不等于 目标分类))  41178
      
ImplementAnalyseThreeTreeLeafLifeOpeComRespDto implementAnalyseThreeTreeLeafLifeOpeComRespDto_2 = null;
    if(implementAnalyseLifeCycleAddOpeTypeComRespDto_2 !=null){
          ImplementAnalyseThreeTreeLeafLifeOpeComReqDto implementAnalyseThreeTreeLeafLifeOpeComReqDto_2=new ImplementAnalyseThreeTreeLeafLifeOpeComReqDto();
  implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setTargetCycleContentTypeCode("OBJECTIVE");//sourceId:926046_1_41179
if(implementAnalyseLifeCycleAddOpeTypeComRespDto_2!=null){
      implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setSubjectLifeCycleOpt(implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:926044_1_41179
implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setEvaObjTableTypeCode(implementAnalyseLifeCycleAddOpeTypeComRespDto_2.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:926045_1_41179
    }
if(circulationCollectionsRes_4!=null){
      implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setEvaObjEntityId(circulationCollectionsRes_4.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:926040_1_41179
implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setTargetCycleContentId(circulationCollectionsRes_4.getEntityId());//SimpleFieldAssign//sourceId:926042_1_41179
    }
if(reqDto!=null){
      implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:926041_1_41179
implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:926043_1_41179
    }
  
    /*D3执行分析三棵树叶子生命周期操作(公共)[6591]   */
    Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getSubjectLifeCycleOpt(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-生命周期操作不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getEvaObjEntityId(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getEvaObjTableTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象内容表类型编码不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getEvaObjTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getTargetCycleContentTypeCode(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getTargetCycleContentId(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2.getTargetId(),"D3执行新增或删除三棵树叶子节点(公共)-D3执行分析三棵树叶子生命周期操作(公共)-冗余目标ID不能为空",false);
      implementAnalyseThreeTreeLeafLifeOpeComRespDto_2 = implementAnalyseThreeTreeLeafLifeOpeCom(implementAnalyseThreeTreeLeafLifeOpeComReqDto_2)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
    }
//ModelCode: circulationEnd
        }
      
    }
      }
ImplementAddOrDelThreeTreeLeafComRespDto retData = new ImplementAddOrDelThreeTreeLeafComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3执行分析三棵树叶子生命周期操作(公共)[6591]
   * gen by moon at 5/11/2023, 8:48:43 PM
   */
  @Trace(operationName = "D3执行分析三棵树叶子生命周期操作(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyseThreeTreeLeafLifeOpeComRespDto implementAnalyseThreeTreeLeafLifeOpeCom(ImplementAnalyseThreeTreeLeafLifeOpeComReqDto reqDto){
    
      
      //virtualUsage 3-3-03查指标详情  41122
      OmsTargetObjective omsTargetObjective = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq.setIsArchive("FALSE");//sourceId:924109_1_41122
if(reqDto!=null){
      queryTargetObjDetailReq.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:924107_1_41122
queryTargetObjDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:924119_1_41122
    }
  
    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq.getObjectiveId(),"D3执行分析三棵树叶子生命周期操作(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getTargetId(),"D3执行分析三棵树叶子生命周期操作(公共)-3-3-03查指标详情-冗余目标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getIsArchive(),"D3执行分析三棵树叶子生命周期操作(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
if((reqDto!= null&&  reqDto.getSubjectLifeCycleOpt() !=null && reqDto.getSubjectLifeCycleOpt().equals("DELETE"))) {
        //if(D3执行分析三棵树叶子生命周期操作(公共).生命周期操作 等于 删除)  41131
        
if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT")||reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))) {
        //if((D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体部门 or D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体个人))  41136
        
DeleteOkrTreeTargetCycleComRespDto deleteOkrTreeTargetCycleComRespDto = null;
    DeleteOkrTreeTargetCycleComReqDto deleteOkrTreeTargetCycleComReqDto=new DeleteOkrTreeTargetCycleComReqDto();
  if(reqDto!=null){
      deleteOkrTreeTargetCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1627979_1_41137
deleteOkrTreeTargetCycleComReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:925733_1_41137
deleteOkrTreeTargetCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925734_1_41137
deleteOkrTreeTargetCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925737_1_41137
deleteOkrTreeTargetCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925736_1_41137
deleteOkrTreeTargetCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925735_1_41137
    }
  
    /*D3删除OKR树目标周期(公共)[3248]   */
    Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getEvaObjEntityId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-部门或身份人员ID不能为空",false);
Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getEvaObjTableTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-被评对象内容表类型编码不能为空",false);
Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getEvaObjTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-被评对象类型编码不能为空",false);
Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getTargetCycleContentTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getTargetCycleContentId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(deleteOkrTreeTargetCycleComReqDto.getTargetId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3删除OKR树目标周期(公共)-冗余目标ID不能为空",false);
      deleteOkrTreeTargetCycleComRespDto = timingTaskService.deleteOkrTreeTargetCycleCom(deleteOkrTreeTargetCycleComReqDto)/*vcase invoke isSameApp*/;
      
      
      
      }
else if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))){
       //elseif(D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 一级部门目标任务责任部门)  41139
      
LifecycleActionsDeptObjTreeAncestorsLeavesComRespDto lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto = null;
    if(omsTargetObjective !=null){
          LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto=new LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto();
  lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setTableTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:925770_1_41140
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:925771_1_41140
if(reqDto!=null){
      lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setLifecyCycleOperationType(reqDto.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925767_1_41140
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925768_1_41140
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925769_1_41140
    }
if(omsTargetObjective!=null){
      lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setLevelNumber(omsTargetObjective.getLevelNumber());//SimpleFieldAssign//sourceId:925772_1_41140
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.setParentObjectiveId(omsTargetObjective.getParentObjectiveId());//SimpleFieldAssign//sourceId:925773_1_41140
    }
  
    /*D3执行生命周期操作部门目标任务书祖先叶子(公共)[5183]   */
    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getLifecyCycleOperationType(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-生命周期操作类型不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getTargetCycleContentTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getTargetCycleContentId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容ID不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getTableTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getLevelNumber(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-层级不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto.getSpaceId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-创建于空间ID不能为空",false);
      lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto = timingTaskService.lifecycleActionsDeptObjTreeAncestorsLeavesCom(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    }
      }
else if((reqDto!= null&&  reqDto.getSubjectLifeCycleOpt() !=null && reqDto.getSubjectLifeCycleOpt().equals("ARCHIVE"))){
       //elseif(D3执行分析三棵树叶子生命周期操作(公共).生命周期操作 等于 存档)  41132
      
if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT")||reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))) {
        //if((D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体部门 or D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体个人))  41153
        
ArchiveOkrTreeTargetCycleComRespDto archiveOkrTreeTargetCycleComRespDto = null;
    ArchiveOkrTreeTargetCycleComReqDto archiveOkrTreeTargetCycleComReqDto=new ArchiveOkrTreeTargetCycleComReqDto();
  archiveOkrTreeTargetCycleComReqDto.setTreeTypeCode("DUTY_SUBJECT");//sourceId:925817_1_41154
if(reqDto!=null){
      archiveOkrTreeTargetCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:925814_1_41154
archiveOkrTreeTargetCycleComReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:925815_1_41154
archiveOkrTreeTargetCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925816_1_41154
archiveOkrTreeTargetCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925818_1_41154
archiveOkrTreeTargetCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925819_1_41154
archiveOkrTreeTargetCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925820_1_41154
    }
  
    /*D3存档OKR树目标周期(公共)[4153]   */
    Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getEvaObjEntityId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getEvaObjTableTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-被评对象内容表类型编码不能为空",false);
Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getEvaObjTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-被评对象类型编码不能为空",false);
Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getTreeTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-树类型编码不能为空",false);
Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getTargetCycleContentTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getTargetCycleContentId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(archiveOkrTreeTargetCycleComReqDto.getTargetId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3存档OKR树目标周期(公共)-冗余目标ID不能为空",false);
      archiveOkrTreeTargetCycleComRespDto = timingTaskService.archiveOkrTreeTargetCycleCom(archiveOkrTreeTargetCycleComReqDto)/*vcase invoke isSameApp*/;
      
      
      
      }
else if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))){
       //elseif(D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 一级部门目标任务责任部门)  41162
      
LifecycleActionsDeptObjTreeAncestorsLeavesComRespDto lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto_1 = null;
    if(omsTargetObjective !=null){
          LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1=new LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto();
  lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setTableTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:925770_1_41163
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:925771_1_41163
if(reqDto!=null){
      lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setLifecyCycleOperationType(reqDto.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925767_1_41163
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925768_1_41163
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925769_1_41163
    }
if(omsTargetObjective!=null){
      lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setLevelNumber(omsTargetObjective.getLevelNumber());//SimpleFieldAssign//sourceId:925772_1_41163
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.setParentObjectiveId(omsTargetObjective.getParentObjectiveId());//SimpleFieldAssign//sourceId:925773_1_41163
    }
  
    /*D3执行生命周期操作部门目标任务书祖先叶子(公共)[5183]   */
    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getLifecyCycleOperationType(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-生命周期操作类型不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getTargetCycleContentTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getTargetCycleContentId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容ID不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getTableTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getLevelNumber(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-层级不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1.getSpaceId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-创建于空间ID不能为空",false);
      lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto_1 = timingTaskService.lifecycleActionsDeptObjTreeAncestorsLeavesCom(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_1)/*vcase invoke isSameApp*/;
      
      
      
           }
    }
    }
else if((reqDto!= null&&  reqDto.getSubjectLifeCycleOpt() !=null && reqDto.getSubjectLifeCycleOpt().equals("UNDO_ARCHIVE"))){
       //elseif(D3执行分析三棵树叶子生命周期操作(公共).生命周期操作 等于 撤销存档)  41134
      
if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT")||reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))) {
        //if((D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体部门 or D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 OKR责任主体个人))  41157
        
UndoToArchiveOkrTreeTargetCycleComRespDto undoToArchiveOkrTreeTargetCycleComRespDto = null;
    UndoToArchiveOkrTreeTargetCycleComReqDto undoToArchiveOkrTreeTargetCycleComReqDto=new UndoToArchiveOkrTreeTargetCycleComReqDto();
  undoToArchiveOkrTreeTargetCycleComReqDto.setTreeTypeCode("DUTY_SUBJECT");//sourceId:925914_1_41158
if(reqDto!=null){
      undoToArchiveOkrTreeTargetCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:925911_1_41158
undoToArchiveOkrTreeTargetCycleComReqDto.setEvaObjTableTypeCode(reqDto.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:925912_1_41158
undoToArchiveOkrTreeTargetCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925913_1_41158
undoToArchiveOkrTreeTargetCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925915_1_41158
undoToArchiveOkrTreeTargetCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925916_1_41158
undoToArchiveOkrTreeTargetCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:925917_1_41158
    }
  
    /*D3撤销想存档OKR树目标周期(公共)[5077]   */
    Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getEvaObjEntityId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getEvaObjTableTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-被评对象内容表类型编码不能为空",false);
Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getEvaObjTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-被评对象类型编码不能为空",false);
Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getTreeTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-树类型编码不能为空",false);
Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getTargetCycleContentTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getTargetCycleContentId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(undoToArchiveOkrTreeTargetCycleComReqDto.getTargetId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3撤销想存档OKR树目标周期(公共)-冗余目标ID不能为空",false);
      undoToArchiveOkrTreeTargetCycleComRespDto = timingTaskService.undoToArchiveOkrTreeTargetCycleCom(undoToArchiveOkrTreeTargetCycleComReqDto)/*vcase invoke isSameApp*/;
      
      
      
      }
else if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))){
       //elseif(D3执行分析三棵树叶子生命周期操作(公共).被评对象类型编码 等于 一级部门目标任务责任部门)  41160
      
LifecycleActionsDeptObjTreeAncestorsLeavesComRespDto lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto_2 = null;
    if(omsTargetObjective !=null){
          LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2=new LifecycleActionsDeptObjTreeAncestorsLeavesComReqDto();
  lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setTableTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:925770_1_41161
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:925771_1_41161
if(reqDto!=null){
      lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setLifecyCycleOperationType(reqDto.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925767_1_41161
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:925768_1_41161
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925769_1_41161
    }
if(omsTargetObjective!=null){
      lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setLevelNumber(omsTargetObjective.getLevelNumber());//SimpleFieldAssign//sourceId:925772_1_41161
lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.setParentObjectiveId(omsTargetObjective.getParentObjectiveId());//SimpleFieldAssign//sourceId:925773_1_41161
    }
  
    /*D3执行生命周期操作部门目标任务书祖先叶子(公共)[5183]   */
    Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getLifecyCycleOperationType(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-生命周期操作类型不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getTargetCycleContentTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getTargetCycleContentId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-关联目标内容ID不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getTableTypeCode(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getLevelNumber(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-层级不能为空",false);
Assert.isNull(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2.getSpaceId(),"D3执行分析三棵树叶子生命周期操作(公共)-D3执行生命周期操作部门目标任务书祖先叶子(公共)-创建于空间ID不能为空",false);
      lifecycleActionsDeptObjTreeAncestorsLeavesComRespDto_2 = timingTaskService.lifecycleActionsDeptObjTreeAncestorsLeavesCom(lifecycleActionsDeptObjTreeAncestorsLeavesComReqDto_2)/*vcase invoke isSameApp*/;
      
      
      
           }
    }
    }
ImplementAnalyseThreeTreeLeafLifeOpeComRespDto retData = new ImplementAnalyseThreeTreeLeafLifeOpeComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3执行分析生命周期操作类型(公共)[6592]
   * gen by moon at 5/11/2023, 8:48:46 PM
   */
  @Trace(operationName = "D3执行分析生命周期操作类型(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyseLifeCycleOpeTypeComRespDto implementAnalyseLifeCycleOpeTypeCom(ImplementAnalyseLifeCycleOpeTypeComReqDto reqDto){
    
      
      ImplementAcceptFieldRespDto receptionServiceRes_3 =null;
if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("EDITING"))) {
        //if(D3执行分析生命周期操作类型(公共).主体生命周期 等于 正在编辑)  41124
        
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  receptionServiceReq.setSubjectLifeCycleOpt("DELETE");//sourceId:924809_1_41125
  
    /*M3生命周期操作类型：删除[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getSubjectLifeCycleOpt(),"D3执行分析生命周期操作类型(公共)-M3生命周期操作类型：删除-生命周期操作不能为空",false);
      receptionServiceRes = nbRefreshTree.implementAcceptField(receptionServiceReq);
      
      
      
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setSubjectLifeCycleOpt(receptionServiceRes.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925270_1_41126
    }
  
    /*M3接收生命周期操作[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getSubjectLifeCycleOpt(),"D3执行分析生命周期操作类型(公共)-M3接收生命周期操作-生命周期操作不能为空",false);
      receptionServiceRes_2 = nbRefreshTree.implementAcceptField(receptionServiceReq_1);
      
      
      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))){
       //elseif(D3执行分析生命周期操作类型(公共).主体生命周期 等于 当前有效)  41127
      
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_4 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_2=new ImplementAcceptFieldReqDto();
  receptionServiceReq_2.setSubjectLifeCycleOpt("ARCHIVE");//sourceId:924812_1_41128
  
    /*M3生命周期操作类型：存档[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getSubjectLifeCycleOpt(),"D3执行分析生命周期操作类型(公共)-M3生命周期操作类型：存档-生命周期操作不能为空",false);
      receptionServiceRes_4 = nbRefreshTree.implementAcceptField(receptionServiceReq_2);
      
      
      
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_6 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_3=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setSubjectLifeCycleOpt(receptionServiceRes_4.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925270_1_41129
    }
  
    /*M3接收生命周期操作[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getSubjectLifeCycleOpt(),"D3执行分析生命周期操作类型(公共)-M3接收生命周期操作-生命周期操作不能为空",false);
      receptionServiceRes_6 = nbRefreshTree.implementAcceptField(receptionServiceReq_3);
      
      
      receptionServiceRes_3 = receptionServiceRes_6;
    }
ImplementAnalyseLifeCycleOpeTypeComRespDto retData = new ImplementAnalyseLifeCycleOpeTypeComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setSubjectLifeCycleOpt(receptionServiceRes_3.getSubjectLifeCycleOpt());//SimpleFieldAssign//sourceId:925272_1
    }
  

  
  
return retData;
  }
/**
   * D3-执行三棵树树叶子节点存在性校验(公共)[6599]
   * gen by moon at 3/19/2024, 11:59:23 AM
   */
  @Trace(operationName = "D3-执行三棵树树叶子节点存在性校验(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCheckThreeTreeExistenceComRespDto implementCheckThreeTreeExistenceCom(ImplementCheckThreeTreeExistenceComReqDto reqDto){


      OmsVirtualOrgMember omsVirtualOrgMember_1 =null;
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 =null;
OmsVirtualOrgMemberDept omsVirtualOrgMemberDept_1 =null;
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_3 =null;
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_5 =null;
//virtualUsage 3-6-02查指标负责人是否存在  41211
      OmsVirtualOrgMember omsVirtualOrgMember = null;
    QueryVirtualOrgMemberDetailReq queryVirtualOrgMemberDetailReq=new QueryVirtualOrgMemberDetailReq();
  queryVirtualOrgMemberDetailReq.setIsPersonCharge("TRUE");//sourceId:1627967_1_41211
queryVirtualOrgMemberDetailReq.setUseScene("TARGET_PLAN_SCENE");//sourceId:1627966_1_41211
queryVirtualOrgMemberDetailReq.setIsArchive("FALSE");//sourceId:927466_1_41211
if(reqDto!=null){
      queryVirtualOrgMemberDetailReq.setEntityId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:927467_1_41211
queryVirtualOrgMemberDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:927468_1_41211
    }

    /*3-6-02查指标负责人是否存在[2379]   */
    Assert.isNull(queryVirtualOrgMemberDetailReq.getIsPersonCharge(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-6-02查指标负责人是否存在-是否负责人不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailReq.getEntityId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-6-02查指标负责人是否存在-冗余内容表主键ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailReq.getEvaluationTemplateId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-6-02查指标负责人是否存在-归属对象ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailReq.getUseScene(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-6-02查指标负责人是否存在-虚拟组织使用场景不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailReq.getIsArchive(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-6-02查指标负责人是否存在-是否存档不能为空",false);
      omsVirtualOrgMember = mOmsVirtualOrgMemberService.queryVirtualOrgMemberDetail(queryVirtualOrgMemberDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsVirtualOrgMember_1 = omsVirtualOrgMember;
//virtualUsage 3-3-09查OKR个人树根节点目标周期详情  41223
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    if(omsVirtualOrgMember !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("OKR_SUBJECT_PERSONAL");//sourceId:927133_1_41223
queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:927135_1_41223
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:927137_1_41223
if(omsVirtualOrgMember!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(omsVirtualOrgMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:927132_1_41223
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:927134_1_41223
queryEvaObjTargetCycleDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:927136_1_41223
    }

    /*3-3-09查OKR个人树根节点目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-冗余目标ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR个人树根节点目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
           }
if((reqDto!= null&&  reqDto.getRespBodyType() !=null && reqDto.getRespBodyType().equals("DEPT"))) {
        //if(D3-执行三棵树树叶子节点存在性校验(公共).责任主体类型 等于 部门)  41200

OmsVirtualOrgMemberDept omsVirtualOrgMemberDept = null;
    ImplementUnrestraintQueryLeadDeptReq implementUnrestraintQueryLeadDeptReq=new ImplementUnrestraintQueryLeadDeptReq();
  implementUnrestraintQueryLeadDeptReq.setDeptType("LEAD_DEPT");//sourceId:927397_1_41216
implementUnrestraintQueryLeadDeptReq.setTableTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:927398_1_41216
implementUnrestraintQueryLeadDeptReq.setIsArchive("FALSE");//sourceId:927406_1_41216
if(reqDto!=null){
      implementUnrestraintQueryLeadDeptReq.setEntityId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:927399_1_41216
implementUnrestraintQueryLeadDeptReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:927408_1_41216
    }

    /*3-6-03执行无约束查牵头部门[3307]   */
    Assert.isNull(implementUnrestraintQueryLeadDeptReq.getDeptType(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-6-03执行无约束查牵头部门-部门类型编码不能为空",false);
Assert.isNull(implementUnrestraintQueryLeadDeptReq.getTableTypeCode(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-6-03执行无约束查牵头部门-冗余内容表类型编码不能为空",false);
Assert.isNull(implementUnrestraintQueryLeadDeptReq.getEntityId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-6-03执行无约束查牵头部门-冗余内容表主键ID不能为空",false);
Assert.isNull(implementUnrestraintQueryLeadDeptReq.getEvaluationTemplateId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-6-03执行无约束查牵头部门-归属对象ID不能为空",false);
Assert.isNull(implementUnrestraintQueryLeadDeptReq.getIsArchive(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-6-03执行无约束查牵头部门-是否存档不能为空",false);
      omsVirtualOrgMemberDept = mOmsVirtualOrgMemberDeptService.implementUnrestraintQueryLeadDept(implementUnrestraintQueryLeadDeptReq)/*vcase invoke 本地 method 方法调用;*/;


      omsVirtualOrgMemberDept_1 = omsVirtualOrgMemberDept;
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    if(omsVirtualOrgMemberDept !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode("OKR_SUBJECT_DEPT");//sourceId:927377_1_41203
queryEvaObjTargetCycleDetailReq_1.setIsParentCycle("TRUE");//sourceId:927379_1_41203
queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:927381_1_41203
if(omsVirtualOrgMemberDept!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(omsVirtualOrgMemberDept.getDeptId());//SimpleFieldAssign//sourceId:927376_1_41203
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:927378_1_41203
queryEvaObjTargetCycleDetailReq_1.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:927380_1_41203
    }

    /*3-3-09查OKR部门树目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsParentCycle(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-冗余目标ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查OKR部门树目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_3 = omsEvaluationObjectTargetCycle_2;
           }
if((reqDto!= null&&  reqDto.getIsUseFirstDept() !=null && reqDto.getIsUseFirstDept().equals("TRUE"))) {
        //if(D3-执行三棵树树叶子节点存在性校验(公共).是否用于一级部门 等于 是)  41202

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_4 = null;
    if(omsVirtualOrgMemberDept !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_2.setEvaObjTypeCode("FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:927387_1_41204
queryEvaObjTargetCycleDetailReq_2.setIsParentCycle("TRUE");//sourceId:927389_1_41204
queryEvaObjTargetCycleDetailReq_2.setIsArchive("FALSE");//sourceId:927391_1_41204
if(omsVirtualOrgMemberDept!=null){
      queryEvaObjTargetCycleDetailReq_2.setEvaObjEntityId(omsVirtualOrgMemberDept.getDeptId());//SimpleFieldAssign//sourceId:927386_1_41204
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_2.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:927388_1_41204
queryEvaObjTargetCycleDetailReq_2.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:927390_1_41204
    }

    /*3-3-09查部门目标任务书树目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjEntityId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTypeCode(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getTargetCycleContentId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsParentCycle(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getTargetId(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-冗余目标ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsArchive(),"D3-执行三棵树树叶子节点存在性校验(公共)-3-3-09查部门目标任务书树目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_4 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_5 = omsEvaluationObjectTargetCycle_4;
           }
      }
      }
ImplementCheckThreeTreeExistenceComRespDto retData = new ImplementCheckThreeTreeExistenceComRespDto();
  if(omsVirtualOrgMemberDept_1!=null){
      retData.setDeptId(omsVirtualOrgMemberDept_1.getDeptId());//SimpleFieldAssign//sourceId:927475_1
    }
if(omsVirtualOrgMember_1!=null){
retData.setOriginalRoleMemberId(omsVirtualOrgMember_1.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1168031_1
    }
if(omsEvaluationObjectTargetCycle_1!=null){
      retData.setOkrPsEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:927477_1
    }
if(omsEvaluationObjectTargetCycle_3!=null){
      retData.setOkrDptEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_3.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:927478_1
    }
if(omsEvaluationObjectTargetCycle_5!=null){
      retData.setMLevelEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_5.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:927479_1
    }




return retData;
  }
/**
   * D3分析被评对象内容表类型编码(公共)[6991]
   * gen by moon at 5/30/2023, 3:16:06 PM
   */
  @Trace(operationName = "D3分析被评对象内容表类型编码(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyseEvaObjTableTypeCodeComRespDto implementAnalyseEvaObjTableTypeCodeCom(ImplementAnalyseEvaObjTableTypeCodeComReqDto reqDto){


      ImplementGainInParameterFieldsRespDto receptionServiceRes_3 =null;
if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("EVA_OBJECT"))) {
        //if(D3分析被评对象内容表类型编码(公共).被评对象类型编码 等于 评价对象)  43346

//ModelCode: receptionService
        ImplementGainInParameterFieldsRespDto receptionServiceRes = null;
    ImplementGainInParameterFieldsReqDto receptionServiceReq=new ImplementGainInParameterFieldsReqDto();
  receptionServiceReq.setEvaObjTableTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:989252_1_43350

    /*M3约定为：空间表[6965]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTableTypeCode(),"D3分析被评对象内容表类型编码(公共)-M3约定为：空间表-被评对象内容表类型编码不能为空",false);
      receptionServiceRes = nbRefreshTree.implementGainInParameterFields(receptionServiceReq);



//ModelCode: receptionService
        ImplementGainInParameterFieldsRespDto receptionServiceRes_2 = null;
    ImplementGainInParameterFieldsReqDto receptionServiceReq_1=new ImplementGainInParameterFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setEvaObjTableTypeCode(receptionServiceRes.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989257_1_43351
    }

    /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getEvaObjTableTypeCode(),"D3分析被评对象内容表类型编码(公共)-M3接收上文出参值-被评对象内容表类型编码不能为空",false);
      receptionServiceRes_2 = nbRefreshTree.implementGainInParameterFields(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT")||reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT"))){
       //elseif((D3分析被评对象内容表类型编码(公共).被评对象类型编码 等于 一级部门目标任务责任部门 or D3分析被评对象内容表类型编码(公共).被评对象类型编码 等于 OKR责任主体部门))  43347

//ModelCode: receptionService
        ImplementGainInParameterFieldsRespDto receptionServiceRes_4 = null;
    ImplementGainInParameterFieldsReqDto receptionServiceReq_2=new ImplementGainInParameterFieldsReqDto();
  receptionServiceReq_2.setEvaObjTableTypeCode("OMS_ORG_DEPT");//sourceId:989254_1_43352

    /*M3约定为：部门表[6965]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getEvaObjTableTypeCode(),"D3分析被评对象内容表类型编码(公共)-M3约定为：部门表-被评对象内容表类型编码不能为空",false);
      receptionServiceRes_4 = nbRefreshTree.implementGainInParameterFields(receptionServiceReq_2);



//ModelCode: receptionService
        ImplementGainInParameterFieldsRespDto receptionServiceRes_6 = null;
    ImplementGainInParameterFieldsReqDto receptionServiceReq_3=new ImplementGainInParameterFieldsReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setEvaObjTableTypeCode(receptionServiceRes_4.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989257_1_43353
    }

    /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getEvaObjTableTypeCode(),"D3分析被评对象内容表类型编码(公共)-M3接收上文出参值-被评对象内容表类型编码不能为空",false);
      receptionServiceRes_6 = nbRefreshTree.implementGainInParameterFields(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
else if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))){
       //elseif(D3分析被评对象内容表类型编码(公共).被评对象类型编码 等于 OKR责任主体个人)  43349

//ModelCode: receptionService
        ImplementGainInParameterFieldsRespDto receptionServiceRes_7 = null;
    ImplementGainInParameterFieldsReqDto receptionServiceReq_4=new ImplementGainInParameterFieldsReqDto();
  receptionServiceReq_4.setEvaObjTableTypeCode("OMS_ORG_INDUCTION_RECORD");//sourceId:989255_1_43354

    /*M3约定为：就职记录表[6965]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getEvaObjTableTypeCode(),"D3分析被评对象内容表类型编码(公共)-M3约定为：就职记录表-被评对象内容表类型编码不能为空",false);
      receptionServiceRes_7 = nbRefreshTree.implementGainInParameterFields(receptionServiceReq_4);



//ModelCode: receptionService
        ImplementGainInParameterFieldsRespDto receptionServiceRes_9 = null;
    ImplementGainInParameterFieldsReqDto receptionServiceReq_5=new ImplementGainInParameterFieldsReqDto();
  if(receptionServiceRes_7!=null){
      receptionServiceReq_5.setEvaObjTableTypeCode(receptionServiceRes_7.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989257_1_43355
    }

    /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getEvaObjTableTypeCode(),"D3分析被评对象内容表类型编码(公共)-M3接收上文出参值-被评对象内容表类型编码不能为空",false);
      receptionServiceRes_9 = nbRefreshTree.implementGainInParameterFields(receptionServiceReq_5);


      receptionServiceRes_3 = receptionServiceRes_9;
    }
ImplementAnalyseEvaObjTableTypeCodeComRespDto retData = new ImplementAnalyseEvaObjTableTypeCodeComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setEvaObjTableTypeCode(receptionServiceRes_3.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:989259_1
    }




return retData;
  }
/**
   * D3构建部门目标任务书树(公共)[6595]
   * gen by moon at 10/9/2023, 1:15:27 AM
   */
  @Trace(operationName = "D3构建部门目标任务书树(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCreateFlevelObjTaskTreeDeptComRespDto implementCreateFlevelObjTaskTreeDeptCom(ImplementCreateFlevelObjTaskTreeDeptComReqDto reqDto){


      //virtualUsage D3-查询指标公共详情(公共)  41166
      QueryComTargetObjDetailComRespDto queryComTargetObjDetailComRespDto = null;
    QueryComTargetObjDetailComReqDto queryComTargetObjDetailComReqDto=new QueryComTargetObjDetailComReqDto();
  if(reqDto!=null){
      queryComTargetObjDetailComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:926049_1_41166
queryComTargetObjDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:926050_1_41166
    }

    /*D3-查询指标公共详情(公共)[5584]   */
    Assert.isNull(queryComTargetObjDetailComReqDto.getObjectiveId(),"D3构建部门目标任务书树(公共)-D3-查询指标公共详情(公共)-指标ID不能为空",false);
Assert.isNull(queryComTargetObjDetailComReqDto.getEvaluationTemplateId(),"D3构建部门目标任务书树(公共)-D3-查询指标公共详情(公共)-冗余评价模板ID不能为空",false);
      queryComTargetObjDetailComRespDto = indexSystemService.queryComTargetObjDetailCom(queryComTargetObjDetailComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3-执行三棵树树叶子节点存在性校验(公共)  46749
      ImplementCheckThreeTreeExistenceComRespDto implementCheckThreeTreeExistenceComRespDto = null;
    if(queryComTargetObjDetailComRespDto !=null){
          ImplementCheckThreeTreeExistenceComReqDto implementCheckThreeTreeExistenceComReqDto=new ImplementCheckThreeTreeExistenceComReqDto();
  if(reqDto!=null){
      implementCheckThreeTreeExistenceComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1072669_1_46749
implementCheckThreeTreeExistenceComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1072673_1_46749
    }
if(queryComTargetObjDetailComRespDto!=null){
      implementCheckThreeTreeExistenceComReqDto.setRespBodyType(queryComTargetObjDetailComRespDto.getRespBodyType());//SimpleFieldAssign//sourceId:1072671_1_46749
implementCheckThreeTreeExistenceComReqDto.setIsUseFirstDept(queryComTargetObjDetailComRespDto.getIsUseFirstDept());//SimpleFieldAssign//sourceId:1072672_1_46749
implementCheckThreeTreeExistenceComReqDto.setTargetId(queryComTargetObjDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1072670_1_46749
    }

    /*D3-执行三棵树树叶子节点存在性校验(公共)[6599]   */
    Assert.isNull(implementCheckThreeTreeExistenceComReqDto.getObjectiveId(),"D3构建部门目标任务书树(公共)-D3-执行三棵树树叶子节点存在性校验(公共)-指标ID不能为空",false);
Assert.isNull(implementCheckThreeTreeExistenceComReqDto.getRespBodyType(),"D3构建部门目标任务书树(公共)-D3-执行三棵树树叶子节点存在性校验(公共)-责任主体类型不能为空",false);
Assert.isNull(implementCheckThreeTreeExistenceComReqDto.getIsUseFirstDept(),"D3构建部门目标任务书树(公共)-D3-执行三棵树树叶子节点存在性校验(公共)-是否用于一级部门不能为空",false);
Assert.isNull(implementCheckThreeTreeExistenceComReqDto.getTargetId(),"D3构建部门目标任务书树(公共)-D3-执行三棵树树叶子节点存在性校验(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementCheckThreeTreeExistenceComReqDto.getEvaluationTemplateId(),"D3构建部门目标任务书树(公共)-D3-执行三棵树树叶子节点存在性校验(公共)-冗余评价模板ID不能为空",false);
      implementCheckThreeTreeExistenceComRespDto = implementCheckThreeTreeExistenceCom(implementCheckThreeTreeExistenceComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//virtualUsage D2比较入参的部门ID与指标的牵头部门ID是否相同  46750
      ImplementTwoValuesIsEqualityComRespDto implementTwoValuesIsEqualityComRespDto = null;
    if(implementCheckThreeTreeExistenceComRespDto !=null){
          ImplementTwoValuesIsEqualityComReqDto implementTwoValuesIsEqualityComReqDto=new ImplementTwoValuesIsEqualityComReqDto();
  if(reqDto!=null){
      implementTwoValuesIsEqualityComReqDto.setCustomField(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1072772_1_46750
    }
if(implementCheckThreeTreeExistenceComRespDto!=null){
      implementTwoValuesIsEqualityComReqDto.setCustomField1(implementCheckThreeTreeExistenceComRespDto.getDeptId());//SimpleFieldAssign//sourceId:1072773_1_46750
    }

    /*D2比较入参的部门ID与指标的牵头部门ID是否相同[6425]   */

      implementTwoValuesIsEqualityComRespDto = fwCompInterfaceModeClient.implementTwoValuesIsEqualityCom(implementTwoValuesIsEqualityComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((queryComTargetObjDetailComRespDto!= null&& queryComTargetObjDetailComRespDto.getRespBodyType() != null &&queryComTargetObjDetailComRespDto!= null&&  queryComTargetObjDetailComRespDto.getRespBodyType() !=null && queryComTargetObjDetailComRespDto.getRespBodyType().equals("DEPT")&&queryComTargetObjDetailComRespDto!= null&&  queryComTargetObjDetailComRespDto.getIsUseFirstDept() !=null && queryComTargetObjDetailComRespDto.getIsUseFirstDept().equals("TRUE")&&implementCheckThreeTreeExistenceComRespDto!= null&& implementCheckThreeTreeExistenceComRespDto.getMLevelEvaObjTargetCycleId() == null &&implementTwoValuesIsEqualityComRespDto!= null&& implementTwoValuesIsEqualityComRespDto.getTureOrFalse()!=null && implementTwoValuesIsEqualityComRespDto.getTureOrFalse().equals("TRUE"))) {
        //if((D3-查询指标公共详情(公共).责任主体类型 值不等于空  and D3-查询指标公共详情(公共).责任主体类型 等于 部门 and D3-查询指标公共详情(公共).是否用于一级部门 等于 是 and D3-执行三棵树树叶子节点存在性校验(公共).部门目标任务书目标周期ID 值等于空  and D2比较入参的部门ID与指标的牵头部门ID是否相同.是否相等 等于 是))  41167

List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:926127_1_41168
queryEvaObjTargetCycleListReq.setEvaObjTableTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:926128_1_41168
queryEvaObjTargetCycleListReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:926129_1_41168
queryEvaObjTargetCycleListReq.setTreeTypeCode("EVALUATION_TREE");//sourceId:926130_1_41168
queryEvaObjTargetCycleListReq.setTargetCycleContentTypeCode("OBJECTIVE");//sourceId:926131_1_41168
queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:926134_1_41168
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:926136_1_41168
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:926137_1_41168
    }

    /*3-3-09查被评对象目标周期列表（根据周期时间范围）[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjEntityId(),"D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTableTypeCode(),"D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-被评对象内容表类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(),"D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getTreeTypeCode(),"D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-树类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentTypeCode(),"D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(),"D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3构建部门目标任务书树(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;



boolean bOOLEAN ;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_2=new ArrayList<>();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      listOmsEvaluationObjectTargetCycle_2 = //objList-to-objLists
        listOmsEvaluationObjectTargetCycle.stream().map(item -> {
      OmsEvaluationObjectTargetCycle elm = new OmsEvaluationObjectTargetCycle();
      elm.setEvaObjTargetCycleCode(item.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:198342_2_41169
elm.setParentEvaObjTargetCycleId(item.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:198343_2_41169
elm.setTargetCycleName(item.getTargetCycleName());//SimpleFieldAssign//sourceId:198375_2_41169
elm.setCyclelAlias(item.getCyclelAlias());//SimpleFieldAssign//sourceId:198376_2_41169
elm.setEvaObjTableTypeCode("OMS_ORG_DEPT");//sourceId:198346_2_41169
elm.setEvaObjTypeCode("FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:198347_2_41169
elm.setTreeTypeCode("DEP_OBJ_MIS_STA");//sourceId:198344_2_41169
elm.setTargetCycleContentTypeCode(item.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:198350_2_41169
elm.setTargetCycleContentId(item.getTargetCycleContentId());//SimpleFieldAssign//sourceId:198349_2_41169
elm.setIsTarget(item.getIsTarget());//SimpleFieldAssign//sourceId:198351_2_41169
elm.setIndicatorKind(item.getIndicatorKind());//SimpleFieldAssign//sourceId:198383_2_41169
elm.setIsCustomObjective(item.getIsCustomObjective());//SimpleFieldAssign//sourceId:198384_2_41169
elm.setIsUseFirstDept(item.getIsUseFirstDept());//SimpleFieldAssign//sourceId:198372_2_41169
elm.setCorrelationLastTargetCatId(item.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:198373_2_41169
elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:198355_2_41169
elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:198381_2_41169
elm.setIsParentCycle(item.getIsParentCycle());//SimpleFieldAssign//sourceId:198352_2_41169
elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:198354_2_41169
elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:198353_2_41169
elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:198368_2_41169
elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:198369_2_41169
elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:198356_2_41169
elm.setCycleTypeInstanceCode(item.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:198357_2_41169
elm.setCycleNumberShortName(item.getCycleNumberShortName());//SimpleFieldAssign//sourceId:198377_2_41169
elm.setHaveProcessCycle(item.getHaveProcessCycle());//SimpleFieldAssign//sourceId:198385_2_41169
elm.setTargetReached(item.getTargetReached());//SimpleFieldAssign//sourceId:198374_2_41169
elm.setTaskStatus(item.getTaskStatus());//SimpleFieldAssign//sourceId:198361_2_41169
elm.setTotalLength(item.getTotalLength());//SimpleFieldAssign//sourceId:198378_2_41169
elm.setDelaySurplusLength(item.getDelaySurplusLength());//SimpleFieldAssign//sourceId:198379_2_41169
elm.setDeviateLength(item.getDeviateLength());//SimpleFieldAssign//sourceId:198380_2_41169
elm.setBizSceneCode(item.getBizSceneCode());//SimpleFieldAssign//sourceId:198362_2_41169
elm.setEvaluationSubjectTypeCode(item.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:198363_2_41169
elm.setEvaluationTemplateTypeCode(item.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:198364_2_41169
elm.setPlanningType(item.getPlanningType());//SimpleFieldAssign//sourceId:198365_2_41169
elm.setTargetId(item.getTargetId());//SimpleFieldAssign//sourceId:198370_2_41169
elm.setEvaluationTemplateId(item.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:198366_2_41169
elm.setEvaluationSubjectId(item.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:198371_2_41169
elm.setReportUpdateTime(item.getReportUpdateTime());//SimpleFieldAssign//sourceId:198358_2_41169
elm.setSortCreateTime(item.getSortCreateTime());//SimpleFieldAssign//sourceId:198359_2_41169
elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:198360_2_41169
elm.setRelativeOrderNumber(item.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:198382_2_41169
elm.setBatchCode(item.getBatchCode());//SimpleFieldAssign//sourceId:198367_2_41169
if(reqDto!=null){
      elm.setEvaObjEntityId(reqDto.getEvaObjEntityId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:198345_2_41169
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:926091_1_41169
    }

    /*3-3-09批量增被评对象目标周期[2494]   */

      bOOLEAN = mOmsEvaluationObjectTargetCycleService.batchAddEvaObjTargetCycle(listOmsEvaluationObjectTargetCycle_2)/*vcase invoke 本地 method 方法调用;*/;



           }
QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
    QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto=new QueryClassMatchResultToAnswerDetailComReqDto();
  queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("CYCLE_SCHEME_CLASS");//CUSTOM_CONVENTION//sourceId:1072680_1_46752
queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1072759_1_46752
if(reqDto!=null){
      queryClassMatchResultToAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1072713_1_46752
    }

    /*D2-3查询配置(周期模式与是否开启中期)[3088]   */
    Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getResultAspObjId(),"D3构建部门目标任务书树(公共)-D2-3查询配置(周期模式与是否开启中期)-开通对象ID不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(),"D3构建部门目标任务书树(公共)-D2-3查询配置(周期模式与是否开启中期)-分组标识不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(),"D3构建部门目标任务书树(公共)-D2-3查询配置(周期模式与是否开启中期)-是否标准答案不能为空",false);
      queryClassMatchResultToAnswerDetailComRespDto = fwCompConfSchemeClient.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



BatchAddTreeLeafWeightSetComRespDto batchAddTreeLeafWeightSetComRespDto = null;
    if(queryClassMatchResultToAnswerDetailComRespDto !=null&&queryComTargetObjDetailComRespDto !=null){
          BatchAddTreeLeafWeightSetComReqDto batchAddTreeLeafWeightSetComReqDto=new BatchAddTreeLeafWeightSetComReqDto();
  batchAddTreeLeafWeightSetComReqDto.setEvaObjTypeCode("FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:1072662_1_46748
if(reqDto!=null){
      batchAddTreeLeafWeightSetComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1072661_1_46748
batchAddTreeLeafWeightSetComReqDto.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1072663_1_46748
batchAddTreeLeafWeightSetComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1072664_1_46748
    }
if(queryClassMatchResultToAnswerDetailComRespDto!=null){
      batchAddTreeLeafWeightSetComReqDto.setCycleMode(queryClassMatchResultToAnswerDetailComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1072665_1_46748
    }
if(queryComTargetObjDetailComRespDto!=null){
      batchAddTreeLeafWeightSetComReqDto.setBatchCode(queryComTargetObjDetailComRespDto.getBatchCode());//SimpleFieldAssign//sourceId:1168039_1_46748
    }

    /*D3批量增树叶子权重设置(公共)[7150]   */
    Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getEvaObjEntityId(),"D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getEvaObjTypeCode(),"D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-被评对象类型编码不能为空",false);
Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getTargetCycleContentId(),"D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-关联目标内容ID不能为空",false);
Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getEvaluationTemplateId(),"D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getCycleMode(),"D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-周期模式不能为空",false);
Assert.isNull(batchAddTreeLeafWeightSetComReqDto.getBatchCode(),"D3构建部门目标任务书树(公共)-D3批量增树叶子权重设置(公共)-批次标识不能为空",false);
      batchAddTreeLeafWeightSetComRespDto = weightTargetService.batchAddTreeLeafWeightSetCom(batchAddTreeLeafWeightSetComReqDto)/*vcase invoke isSameApp*/;



           }
GenerateDeptObjTreeLeavesComRespDto generateDeptObjTreeLeavesComRespDto = null;
    if(queryClassMatchResultToAnswerDetailComRespDto !=null){
    GenerateDeptObjTreeLeavesComReqDto generateDeptObjTreeLeavesComReqDto=new GenerateDeptObjTreeLeavesComReqDto();
  generateDeptObjTreeLeavesComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:926092_1_41170
if(reqDto!=null){
      generateDeptObjTreeLeavesComReqDto.setEntityId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:926093_1_41170
    }
if(queryClassMatchResultToAnswerDetailComRespDto!=null){
      generateDeptObjTreeLeavesComReqDto.setCycleMode(queryClassMatchResultToAnswerDetailComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1072778_1_41170
generateDeptObjTreeLeavesComReqDto.setOpenMidCycle(queryClassMatchResultToAnswerDetailComRespDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1072779_1_41170
    }

    /*D3生成部门目标任务书树叶子(公共)[2332]   */
    Assert.isNull(generateDeptObjTreeLeavesComReqDto.getEntityId(),"D3构建部门目标任务书树(公共)-D3生成部门目标任务书树叶子(公共)-指标ID不能为空",false);
Assert.isNull(generateDeptObjTreeLeavesComReqDto.getSpaceId(),"D3构建部门目标任务书树(公共)-D3生成部门目标任务书树叶子(公共)-创建于空间ID不能为空",false);
Assert.isNull(generateDeptObjTreeLeavesComReqDto.getCycleMode(),"D3构建部门目标任务书树(公共)-D3生成部门目标任务书树叶子(公共)-周期模式不能为空",false);
Assert.isNull(generateDeptObjTreeLeavesComReqDto.getOpenMidCycle(),"D3构建部门目标任务书树(公共)-D3生成部门目标任务书树叶子(公共)-是否开启中期不能为空",false);
      generateDeptObjTreeLeavesComRespDto = timingTaskService.generateDeptObjTreeLeavesCom(generateDeptObjTreeLeavesComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementCorrectionDeptObjTreeLeavesCodeComRespDto implementCorrectionDeptObjTreeLeavesCodeComRespDto = null;
    if(queryComTargetObjDetailComRespDto !=null){
          ImplementCorrectionDeptObjTreeLeavesCodeComReqDto implementCorrectionDeptObjTreeLeavesCodeComReqDto=new ImplementCorrectionDeptObjTreeLeavesCodeComReqDto();
  if(reqDto!=null){
      implementCorrectionDeptObjTreeLeavesCodeComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:926098_1_41171
implementCorrectionDeptObjTreeLeavesCodeComReqDto.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:926099_1_41171
implementCorrectionDeptObjTreeLeavesCodeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:926094_1_41171
    }
if(queryComTargetObjDetailComRespDto!=null){
      implementCorrectionDeptObjTreeLeavesCodeComReqDto.setParentObjectiveId(queryComTargetObjDetailComRespDto.getParentObjectiveId());//SimpleFieldAssign//sourceId:926097_1_41171
implementCorrectionDeptObjTreeLeavesCodeComReqDto.setCorrelationLastTargetCatId(queryComTargetObjDetailComRespDto.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:926096_1_41171
implementCorrectionDeptObjTreeLeavesCodeComReqDto.setLevelNumber(queryComTargetObjDetailComRespDto.getLevelNumber());//SimpleFieldAssign//sourceId:926095_1_41171
    }

    /*D3执行修正部门目标任务书树叶子标识(公共)[5940]   */
    Assert.isNull(implementCorrectionDeptObjTreeLeavesCodeComReqDto.getEvaObjEntityId(),"D3构建部门目标任务书树(公共)-D3执行修正部门目标任务书树叶子标识(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementCorrectionDeptObjTreeLeavesCodeComReqDto.getObjectiveId(),"D3构建部门目标任务书树(公共)-D3执行修正部门目标任务书树叶子标识(公共)-指标ID不能为空",false);
Assert.isNull(implementCorrectionDeptObjTreeLeavesCodeComReqDto.getCorrelationLastTargetCatId(),"D3构建部门目标任务书树(公共)-D3执行修正部门目标任务书树叶子标识(公共)-关联末级目标分类ID不能为空",false);
Assert.isNull(implementCorrectionDeptObjTreeLeavesCodeComReqDto.getLevelNumber(),"D3构建部门目标任务书树(公共)-D3执行修正部门目标任务书树叶子标识(公共)-层级不能为空",false);
Assert.isNull(implementCorrectionDeptObjTreeLeavesCodeComReqDto.getEvaluationTemplateId(),"D3构建部门目标任务书树(公共)-D3执行修正部门目标任务书树叶子标识(公共)-冗余评价模板ID不能为空",false);
      implementCorrectionDeptObjTreeLeavesCodeComRespDto = targetCycleService.implementCorrectionDeptObjTreeLeavesCodeCom(implementCorrectionDeptObjTreeLeavesCodeComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComRespDto implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComRespDto = null;
    ImplementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto=new ImplementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto();
if(reqDto!=null){
      implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1072775_1_46751
implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.setTargetCycleContentId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:1072776_1_46751
implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1072777_1_46751
    }

    /*D3初始化部门目标任务书当前叶子父子状态(公共)[7213]   */
    Assert.isNull(implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.getEvaObjEntityId(),"D3构建部门目标任务书树(公共)-D3初始化部门目标任务书当前叶子父子状态(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.getTargetCycleContentId(),"D3构建部门目标任务书树(公共)-D3初始化部门目标任务书当前叶子父子状态(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto.getEvaluationTemplateId(),"D3构建部门目标任务书树(公共)-D3初始化部门目标任务书当前叶子父子状态(公共)-冗余评价模板ID不能为空",false);
      implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComRespDto = offStateService.implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeCom(implementDeptObjTaskCurrentLeaftAssistNodeStatusInitializeComReqDto)/*vcase invoke isSameApp*/;



      }
ImplementCreateFlevelObjTaskTreeDeptComRespDto retData = new ImplementCreateFlevelObjTaskTreeDeptComRespDto();





return retData;
  }
  //
}
